{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 定义算法\n",
    "\n",
    "DQN 经验回放的算法中的均匀采样算法，可能会忘记一些重要的、以后使用的经验数据。针对这样的问题，PER_DQN 提出了优先级经验回放（prioritized experience reolay）的技术来解决，这种方法应用到 DQN 获得了更好的效果。PER_DQN 成功的原因有：1. 提出了sum tree这样复杂度为O(logn)的高效数据结构。 2. 正确估计了 weighted importance sampling. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1、 定义模型\n",
    "\n",
    "这里的 PER_DQN 的模型和 DQN 中类似，也是用的三层的MLP。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, n_states,n_actions,hidden_dim=128):\n",
    "        \"\"\" 初始化q网络，为全连接网络\n",
    "        \"\"\"\n",
    "        super(MLP, self).__init__()\n",
    "        self.fc1 = nn.Linear(n_states, hidden_dim) # 输入层\n",
    "        self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n",
    "        self.fc3 = nn.Linear(hidden_dim, n_actions) # 输出层\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 各层对应的激活函数\n",
    "        x = F.relu(self.fc1(x)) \n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc3(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2、定义经验回放\n",
    "\n",
    "这里的经验回放是和DQN中最大的不同。它使用了sum tree的数据结构，它是一种特殊的二叉树，其父亲节点的值等于子节点的和。节点上的值，定义为每个样本的优先度，这里就用TDerror来衡量。叶子上的数值就是样本优先度。\n",
    "\n",
    "sum tree 采样过程：根据根节点的priority和采样样本数，划分采样的区间，然后在这些区间中均应采样得到所要选取的样本的优先度。从根节点开始，逐层将样本的优先度和节点的优先度进行对比，最终可以得到所要采样的叶子样本。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random\n",
    "\n",
    "class SumTree:\n",
    "    '''SumTree for the per(Prioritized Experience Replay) DQN. \n",
    "    This SumTree code is a modified version and the original code is from:\n",
    "    https://github.com/MorvanZhou/Reinforcement-learning-with-tensorflow/blob/master/contents/5.2_Prioritized_Replay_DQN/RL_brain.py\n",
    "    '''\n",
    "    def __init__(self, capacity: int):\n",
    "        self.capacity = capacity\n",
    "        self.data_pointer = 0 #标识目前最新的经验位置，便于查找经验\n",
    "        self.n_entries = 0\n",
    "        self.tree = np.zeros(2 * capacity - 1)\n",
    "        self.data = np.zeros(capacity, dtype = object)\n",
    "\n",
    "    def update(self, tree_idx, p):\n",
    "        '''Update the sampling weight\n",
    "        '''\n",
    "        change = p - self.tree[tree_idx]\n",
    "        self.tree[tree_idx] = p\n",
    "\n",
    "        while tree_idx != 0:\n",
    "            tree_idx = (tree_idx - 1) // 2\n",
    "            self.tree[tree_idx] += change\n",
    "\n",
    "    def add(self, p, data):\n",
    "        '''Adding new data to the sumTree\n",
    "        '''\n",
    "        tree_idx = self.data_pointer + self.capacity - 1\n",
    "        self.data[self.data_pointer] = data\n",
    "        # print (\"tree_idx=\", tree_idx)\n",
    "        # print (\"nonzero = \", np.count_nonzero(self.tree))\n",
    "        self.update(tree_idx, p)\n",
    "\n",
    "        self.data_pointer += 1\n",
    "        if self.data_pointer >= self.capacity:\n",
    "            self.data_pointer = 0\n",
    "\n",
    "        if self.n_entries < self.capacity:\n",
    "            self.n_entries += 1\n",
    "\n",
    "    def get_leaf(self, v):\n",
    "        '''Sampling the data\n",
    "        小于左节点则向左节点寻找；\n",
    "        大于左节点则向右节点寻找，且v减去左节点的值\n",
    "        '''\n",
    "        parent_idx = 0\n",
    "        while True:\n",
    "            cl_idx = 2 * parent_idx + 1\n",
    "            cr_idx = cl_idx + 1\n",
    "            if cl_idx >= len(self.tree):\n",
    "                leaf_idx = parent_idx\n",
    "                break\n",
    "            else:\n",
    "                if v <= self.tree[cl_idx] :\n",
    "                    parent_idx = cl_idx\n",
    "                else:\n",
    "                    v -= self.tree[cl_idx]\n",
    "                    parent_idx = cr_idx\n",
    "\n",
    "        data_idx = leaf_idx - self.capacity + 1\n",
    "        return leaf_idx, self.tree[leaf_idx], self.data[data_idx]\n",
    "\n",
    "    def total(self):\n",
    "        return int(self.tree[0])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class ReplayTree:\n",
    "    '''ReplayTree for the per(Prioritized Experience Replay) DQN. \n",
    "    '''\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity # the capacity for memory replay\n",
    "        self.tree = SumTree(capacity)\n",
    "        self.abs_err_upper = 1.\n",
    "\n",
    "        ## hyper parameter for calculating the importance sampling weight\n",
    "        self.beta_increment_per_sampling = 0.001\n",
    "        self.alpha = 0.6\n",
    "        self.beta = 0.4\n",
    "        self.epsilon = 0.01 \n",
    "        self.abs_err_upper = 1.\n",
    "\n",
    "    def __len__(self):\n",
    "        ''' return the num of storage\n",
    "        '''\n",
    "        return self.tree.total()\n",
    "\n",
    "    def push(self, error, sample):\n",
    "        '''Push the sample into the replay according to the importance sampling weight\n",
    "        '''\n",
    "        p = (np.abs(error) + self.epsilon) ** self.alpha #根据伪代码TD-error需要再求alpha的平方\n",
    "        self.tree.add(p, sample)         \n",
    "\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        '''This is for sampling a batch data and the original code is from:\n",
    "        https://github.com/rlcode/per/blob/master/prioritized_memory.py\n",
    "        采样函数的返回值为：\n",
    "        经验矩阵(s,a,r,s',_)\n",
    "        每一笔经验的id，因为后面需要更新p值，需要知道id\n",
    "        每一笔经验的权重\n",
    "        '''\n",
    "        # 将总区间分为batch_size个小区间，在每个区间中均匀采样一个随机数\n",
    "        # 根据随机数抽取经验\n",
    "        pri_segment = self.tree.total() / batch_size \n",
    "\n",
    "        priorities = []\n",
    "        batch = []\n",
    "        idxs = []\n",
    "\n",
    "        is_weights = []\n",
    "\n",
    "        self.beta = np.min([1., self.beta + self.beta_increment_per_sampling])\n",
    "        min_prob = np.min(self.tree.tree[-self.tree.capacity:]) / self.tree.total() \n",
    "\n",
    "        for i in range(batch_size):\n",
    "            a = pri_segment * i\n",
    "            b = pri_segment * (i+1)\n",
    "\n",
    "            s = random.uniform(a, b)\n",
    "            idx, p, data = self.tree.get_leaf(s)\n",
    "\n",
    "            priorities.append(p)\n",
    "            batch.append(data)\n",
    "            idxs.append(idx)\n",
    "            prob = p / self.tree.total() #prob就是P(i)\n",
    "\n",
    "        sampling_probabilities = np.array(priorities) / self.tree.total()\n",
    "        is_weights = np.power(self.tree.n_entries * sampling_probabilities, -self.beta)\n",
    "        is_weights /= is_weights.max()\n",
    "\n",
    "        # zip(a,b,...)表示把参数矩阵按位合并\n",
    "        # zip(*a)表示把参数矩阵按位拆分\n",
    "        # zip(*batch)=[s],[a],[r],[s'],[done]\n",
    "        # batch=zip(s,a,r,s',done)\n",
    "        return zip(*batch), idxs, is_weights\n",
    "    \n",
    "    def batch_update(self, tree_idx, abs_errors):\n",
    "        '''Update the importance sampling weight\n",
    "        '''\n",
    "        abs_errors += self.epsilon\n",
    "\n",
    "        clipped_errors = np.minimum(abs_errors, self.abs_err_upper)\n",
    "        ps = np.power(clipped_errors, self.alpha)\n",
    "\n",
    "        for ti, p in zip(tree_idx, ps):#广播操作\n",
    "            self.tree.update(ti, p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3、模型算法定义\n",
    "\n",
    "这里使用三层MLP搭建智能体agent，其中和DQN基本一致，这里不再赘述。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "class PER_DQN:\n",
    "    def __init__(self, model, memory, cfg):\n",
    "\n",
    "        self.n_actions = cfg.n_actions  \n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.gamma = cfg.gamma  \n",
    "        ## e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\n",
    "        self.epsilon = cfg.epsilon_start\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end = cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.target_update = cfg.target_update\n",
    "\n",
    "        self.policy_net = model.to(self.device)\n",
    "        self.target_net = model.to(self.device)\n",
    "        ## 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "            target_param.data.copy_(param.data)\n",
    "        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) \n",
    "        self.memory = memory # SumTree 经验回放\n",
    "        self.update_flag = False \n",
    "        \n",
    "    def sample_action(self, state):\n",
    "        ''' sample action with e-greedy policy\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon 指数衰减\n",
    "        # epsilon=min+(max-min)*e^(sample_count/decay)\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            with torch.no_grad():\n",
    "                state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "                q_values = self.policy_net(state)\n",
    "                action = q_values.max(1)[1].item() # 根据Q值选择动作\n",
    "        else:\n",
    "            action = random.randrange(self.n_actions)\n",
    "        return action\n",
    "\n",
    "    def predict_action(self,state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        with torch.no_grad():\n",
    "            state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "            q_values = self.policy_net(state)\n",
    "            action = q_values.max(1)[1].item() \n",
    "        return action\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 不满足一个批量时，不更新策略\n",
    "            return\n",
    "        else:\n",
    "            if not self.update_flag:\n",
    "                print(\"Begin to update!\")\n",
    "                self.update_flag = True\n",
    "        # 采样一个batch\n",
    "        (state_batch, action_batch, reward_batch, next_state_batch, done_batch), idxs_batch, is_weights_batch = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)\n",
    "        action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1) # shape(batchsize,1)\n",
    "        reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float).unsqueeze(1) # shape(batchsize,1)\n",
    "        next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float) # shape(batchsize,n_states)\n",
    "        done_batch = torch.tensor(np.float32(done_batch), device=self.device).unsqueeze(1) # shape(batchsize,1)\n",
    "        q_value_batch = self.policy_net(state_batch).gather(dim=1, index=action_batch) # shape(batchsize,1),requires_grad=True\n",
    "        next_max_q_value_batch = self.target_net(next_state_batch).max(1)[0].detach().unsqueeze(1) # shape(batchsize,1)\n",
    "        expected_q_value_batch = reward_batch + self.gamma * next_max_q_value_batch* (1-done_batch) # shape(batchsize,1)\n",
    "\n",
    "        # loss中根据优先度进行了加权\n",
    "        # torch.mean()不指定dim时返回所有元素的平均值\n",
    "        # [batch_size,1]*[batch_size,1]=[batch_size,1]\n",
    "        # torch.mean([batch_size,1])=[1]\n",
    "        loss = torch.mean(torch.pow((q_value_batch - expected_q_value_batch), 2)*torch.from_numpy(is_weights_batch).to(self.device)) \n",
    "\n",
    "        # loss = nn.MSELoss()(q_value_batch, expected_q_value_batch)   \n",
    "\n",
    "        # np.sum这里起到降维的作用\n",
    "        abs_errors = np.sum(np.abs(q_value_batch.cpu().detach().numpy() - expected_q_value_batch.cpu().detach().numpy()), axis=1)\n",
    "        # 需要更新样本的优先度\n",
    "        self.memory.batch_update(idxs_batch, abs_errors) \n",
    "\n",
    "        # 反向传播\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # 梯度截断，防止梯度爆炸\n",
    "        for param in self.policy_net.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "        if self.sample_count % self.target_update == 0: # 更新 target_net\n",
    "            self.target_net.load_state_dict(self.policy_net.state_dict())  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg, env, agent):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    print(\"开始训练！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state = env.reset()  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = agent.sample_action(state)  # 选择动作\n",
    "            next_state, reward, done, _= env.step(action)  # 更新环境，返回transition\n",
    "\n",
    "            ## PER DQN 特有的内容\n",
    "            policy_val = agent.policy_net(torch.tensor(state, device = cfg.device))[action]\n",
    "            target_val = agent.target_net(torch.tensor(next_state, device = cfg.device))\n",
    "\n",
    "            if done:\n",
    "                error = abs(policy_val - reward)\n",
    "            else:\n",
    "                error = abs(policy_val - reward - cfg.gamma * torch.max(target_val))\n",
    "\n",
    "            agent.memory.push(error.cpu().detach().numpy(), (state, action, reward,\n",
    "                            next_state, done))   # 保存transition\n",
    "            \n",
    "            agent.update()  # 更新智能体\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "        if (i_ep + 1) % cfg.target_update == 0:  # 智能体目标网络更新\n",
    "            agent.target_net.load_state_dict(agent.policy_net.state_dict())\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{agent.epsilon:.3f}\")\n",
    "    print(\"完成训练！\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards}\n",
    "\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state = env.reset()  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step+=1\n",
    "            action = agent.predict_action(state)  # 选择动作\n",
    "            next_state, reward, done, _ = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import os\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    env.seed(seed) # env config\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = gym.make(cfg.env_name) # 创建环境\n",
    "    if cfg.seed !=0:\n",
    "        all_seed(env,seed=cfg.seed)\n",
    "    n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.n\n",
    "    print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n",
    "\n",
    "    cfg.n_actions = env.action_space.n  ## set the env action space\n",
    "    model = MLP(n_states, n_actions, hidden_dim = cfg.hidden_dim) # 创建模型\n",
    "    memory = ReplayTree(cfg.buffer_size)\n",
    "    agent = PER_DQN(model,memory,cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config():\n",
    "    def __init__(self) -> None:\n",
    "        self.env_name = \"CartPole-v1\" # 环境名字\n",
    "        self.new_step_api = True # 是否用gym的新api\n",
    "        self.wrapper = None \n",
    "        self.render = False \n",
    "        self.algo_name = \"PER_DQN\" # 算法名字\n",
    "        self.mode = \"train\" # train or test\n",
    "        self.seed = 0 # 随机种子\n",
    "        self.device = \"cpu\" # device to use\n",
    "        self.train_eps = 100 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.eval_eps = 10 # 评估的回合数\n",
    "        self.eval_per_episode = 5 # 每个回合的评估次数\n",
    "        self.max_steps = 200 # 每个回合的最大步数\n",
    "        self.load_checkpoint = False\n",
    "        self.load_path = \"tasks\" # 加载模型的路径\n",
    "        self.show_fig = False # 是否展示图片\n",
    "        self.save_fig = True # 是否存储图片\n",
    "\n",
    "        # 设置epsilon值\n",
    "        self.epsilon_start = 0.95 # 起始的epsilon值\n",
    "        self.epsilon_end = 0.01 # 终止的epsilon值\n",
    "        self.epsilon_decay = 500 # 衰减率\n",
    "        self.hidden_dim = 256 \n",
    "        self.gamma = 0.95 \n",
    "        self.lr = 0.0001 \n",
    "        self.buffer_size = 100000 # 经验回放的buffer大小\n",
    "        self.batch_size = 64 # batch size\n",
    "        self.target_update = 4 # 目标网络更新频率\n",
    "        self.value_layers = [\n",
    "            {'layer_type': 'linear', 'layer_dim': ['n_states', 256],\n",
    "             'activation': 'relu'},\n",
    "            {'layer_type': 'linear', 'layer_dim': [256, 256],\n",
    "             'activation': 'relu'},\n",
    "            {'layer_type': 'linear', 'layer_dim': [256, 'n_actions'],\n",
    "             'activation': 'none'}]\n",
    "\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,cfg, tag='train'):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态空间维度：4，动作空间维度：2\n",
      "开始训练！\n",
      "Begin to update!\n",
      "回合：10/100，奖励：10.00，Epislon：0.569\n",
      "回合：20/100，奖励：12.00，Epislon：0.443\n",
      "回合：30/100，奖励：10.00，Epislon：0.357\n",
      "回合：40/100，奖励：15.00，Epislon：0.268\n",
      "回合：50/100，奖励：125.00，Epislon：0.103\n",
      "回合：60/100，奖励：67.00，Epislon：0.024\n",
      "回合：70/100，奖励：200.00，Epislon：0.012\n",
      "回合：80/100，奖励：200.00，Epislon：0.010\n",
      "回合：90/100，奖励：200.00，Epislon：0.010\n",
      "回合：100/100，奖励：200.00，Epislon：0.010\n",
      "完成训练！\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始测试！\n",
      "回合：1/20，奖励：200.00\n",
      "回合：2/20，奖励：200.00\n",
      "回合：3/20，奖励：200.00\n",
      "回合：4/20，奖励：200.00\n",
      "回合：5/20，奖励：200.00\n",
      "回合：6/20，奖励：200.00\n",
      "回合：7/20，奖励：200.00\n",
      "回合：8/20，奖励：200.00\n",
      "回合：9/20，奖励：200.00\n",
      "回合：10/20，奖励：200.00\n",
      "回合：11/20，奖励：200.00\n",
      "回合：12/20，奖励：200.00\n",
      "回合：13/20，奖励：200.00\n",
      "回合：14/20，奖励：200.00\n",
      "回合：15/20，奖励：200.00\n",
      "回合：16/20，奖励：200.00\n",
      "回合：17/20，奖励：200.00\n",
      "回合：18/20，奖励：200.00\n",
      "回合：19/20，奖励：200.00\n",
      "回合：20/20，奖励：200.00\n",
      "完成测试\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "# train函数将env和agent结合起来\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"train\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"test\")  # 画出结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.13 ('joyrl')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "996e2c1bcfa8ebbd3aba48733c28d7658f0aec7cda7e9a0e5abbef50d3f90575"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
